logging.h File Reference

#include <map>
#include "spdlog/spdlog.h"
#include "spdlog/async.h"
#include "spdlog/sinks/stdout_color_sinks.h"
#include "spdlog/fmt/ostr.h"
#include "core/utils/singleton.h"

Go to the source code of this file.

Classes
class	wolf::internal::do_not_enter_where_the_wolf_lives::Logger
class	wolf::internal::do_not_enter_where_the_wolf_lives::LoggerManager

Namespaces
namespace	wolf
namespace	wolf::internal
namespace	wolf::internal::do_not_enter_where_the_wolf_lives

Macros
#define	__INTERNAL_WOLF_MAIN_LOGGER_NAME_   "wolf_main_console"
#define	WOLF_STRINGIFY(x)   #x
#define	WOLF_STR_HELPER(x)   WOLF_STRINGIFY(x)
#define	WOLF_ASYNC_QUEUE_LOG_NAMED(name, ...)    wolf::internal::WolfLoggerManager::get().getLogger(name).set_async_queue(x);
	NAMED LOGGING. More...
#define	WOLF_INFO_NAMED(name, ...)
#define	WOLF_INFO_NAMED_COND(name, cond, ...)    if (cond) WOLF_INFO_NAMED(name, __VA_ARGS__);
#define	WOLF_WARN_NAMED(name, ...)
#define	WOLF_WARN_NAMED_COND(name, cond, ...)    if (cond) WOLF_WARN_NAMED(name, __VA_ARGS__);
#define	WOLF_ERROR_NAMED(name, ...)
#define	WOLF_ERROR_NAMED_COND(name, cond, ...)    if (cond) WOLF_ERROR_NAMED(name, __VA_ARGS__);
#define	WOLF_DEBUG_NAMED(name, ...)
#define	WOLF_DEBUG_NAMED_COND(name, cond, ...)
#define	WOLF_TRACE_NAMED(name, ...)
#define	WOLF_TRACE_NAMED_COND(name, cond, ...)
#define	WOLF_ASYNC_QUEUE_LOG(x)   wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_).set_async_queue(x);
	MAIN LOGGING. More...
#define	WOLF_INFO(...)
#define	WOLF_INFO_COND(cond, ...)    if (cond) WOLF_INFO(__VA_ARGS__);
#define	WOLF_WARN(...)
#define	WOLF_WARN_COND(cond, ...)    if (cond) WOLF_WARN(__VA_ARGS__);
#define	WOLF_ERROR(...)
#define	WOLF_ERROR_COND(cond, ...)    if (cond) WOLF_ERROR(__VA_ARGS__);
#define	WOLF_DEBUG(...)
#define	WOLF_DEBUG_COND(cond, ...)
#define	WOLF_TRACE(...)
#define	WOLF_TRACE_COND(cond, ...)
#define	WOLF_PROC_DEBUG(...)
#define	WOLF_PROC_DEBUG_COND(cond, ...)    if (cond) WOLF_PROC_DEBUG(__VA_ARGS__);

Typedefs
using	wolf::internal::do_not_enter_where_the_wolf_lives::LoggerPtr = std::unique_ptr< Logger >
using	wolf::internal::WolfLogger = Singleton< do_not_enter_where_the_wolf_lives::Logger >
using	wolf::internal::WolfLoggerManager = Singleton< do_not_enter_where_the_wolf_lives::LoggerManager >

Variables
static constexpr auto	wolf::internal::do_not_enter_where_the_wolf_lives::repeated_brace

Macro Definition Documentation

__INTERNAL_WOLF_MAIN_LOGGER_NAME_

#define __INTERNAL_WOLF_MAIN_LOGGER_NAME_   "wolf_main_console"

WOLF_ASYNC_QUEUE_LOG

#define WOLF_ASYNC_QUEUE_LOG

(

x

)

wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_).set_async_queue(x);

MAIN LOGGING.

WOLF_ASYNC_QUEUE_LOG_NAMED

#define WOLF_ASYNC_QUEUE_LOG_NAMED	(		name,
			...
	)		wolf::internal::WolfLoggerManager::get().getLogger(name).set_async_queue(x);

NAMED LOGGING.

WOLF_DEBUG

#define WOLF_DEBUG

(

...

)

Value:

    do                                                                                                                \
    {                                                                                                                 \
    } while (0)

WOLF_DEBUG_COND

#define WOLF_DEBUG_COND	(		cond,
			...
	)

Value:

    do                                                                                                                \
    {                                                                                                                 \
    } while (0)

WOLF_DEBUG_NAMED

#define WOLF_DEBUG_NAMED	(		name,
			...
	)

Value:

    do                                                                                                                \
    {                                                                                                                 \
    } while (0)

WOLF_DEBUG_NAMED_COND

#define WOLF_DEBUG_NAMED_COND	(		name,
			cond,
			...
	)

Value:

    do                                                                                                                \
    {                                                                                                                 \
    } while (0)

WOLF_ERROR

#define WOLF_ERROR

(

...

)

Value:

    {                                                                                                                 \
        char this_file[] = __FILE__;                                                                                  \
        wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_)                                            \
            .error("[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__);                  \
    }

WOLF_ERROR_COND

#define WOLF_ERROR_COND	(		cond,
			...
	)		if (cond) WOLF_ERROR(__VA_ARGS__);

WOLF_ERROR_NAMED

#define WOLF_ERROR_NAMED	(		name,
			...
	)

Value:

    {                                                                                                                 \
        char this_file[] = __FILE__;                                                                                  \
        wolf::internal::WolfLoggerManager::get().getLogger(name).error(                                               \
            "[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__);                         \
    }

WOLF_ERROR_NAMED_COND

#define WOLF_ERROR_NAMED_COND	(		name,
			cond,
			...
	)		if (cond) WOLF_ERROR_NAMED(name, __VA_ARGS__);

WOLF_INFO

#define WOLF_INFO

(

...

)

Value:

    {                                                                                                                 \
        char this_file[] = __FILE__;                                                                                  \
        wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_)                                            \
            .info("[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__);                   \
    }

WOLF_INFO_COND

#define WOLF_INFO_COND	(		cond,
			...
	)		if (cond) WOLF_INFO(__VA_ARGS__);

WOLF_INFO_NAMED

#define WOLF_INFO_NAMED	(		name,
			...
	)

Value:

    {                                                                                                                 \
        char this_file[] = __FILE__;                                                                                  \
        wolf::internal::WolfLoggerManager::get().getLogger(name).info(                                                \
            "[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__);                         \
    }

WOLF_INFO_NAMED_COND

#define WOLF_INFO_NAMED_COND	(		name,
			cond,
			...
	)		if (cond) WOLF_INFO_NAMED(name, __VA_ARGS__);

WOLF_PROC_DEBUG

#define WOLF_PROC_DEBUG

(

...

)

Value:

    {                                                                                                                 \
        static_assert(std::is_base_of<ProcessorBase, typename std::remove_pointer<decltype(this)>::type>::value,      \
                      "WOLF_PROC_DEBUG can only be used in processors");                                              \
        /* message will be printed if debug_verbose_level_ != "none" */                                               \
        if (debug_verbose_level_ != "none")                                                                           \
        { /* Print as WOLF_DEBUG even if WOLF_DEBUG is disabled (copied from logging.h) */                            \
            char this_file[] = __FILE__;                                                                              \
            wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_)                                        \
                .debug("[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__);              \
        }                                                                                                             \
    }

WOLF_PROC_DEBUG_COND

#define WOLF_PROC_DEBUG_COND	(		cond,
			...
	)		if (cond) WOLF_PROC_DEBUG(__VA_ARGS__);

WOLF_STR_HELPER

#define WOLF_STR_HELPER

(

x

)

WOLF_STRINGIFY(x)

WOLF_STRINGIFY

#define WOLF_STRINGIFY

(

x

)

#x

WOLF_TRACE

#define WOLF_TRACE

(

...

)

Value:

    do                                                                                                                \
    {                                                                                                                 \
    } while (0)

WOLF_TRACE_COND

#define WOLF_TRACE_COND	(		cond,
			...
	)

Value:

    do                                                                                                                \
    {                                                                                                                 \
    } while (0)

WOLF_TRACE_NAMED

#define WOLF_TRACE_NAMED	(		name,
			...
	)

Value:

    do                                                                                                                \
    {                                                                                                                 \
    } while (0)

WOLF_TRACE_NAMED_COND

#define WOLF_TRACE_NAMED_COND	(		name,
			cond,
			...
	)

Value:

    do                                                                                                                \
    {                                                                                                                 \
    } while (0)

WOLF_WARN

#define WOLF_WARN

(

...

)

Value:

    {                                                                                                                 \
        char this_file[] = __FILE__;                                                                                  \
        wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_)                                            \
            .warn("[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__);                   \
    }

WOLF_WARN_COND

#define WOLF_WARN_COND	(		cond,
			...
	)		if (cond) WOLF_WARN(__VA_ARGS__);

WOLF_WARN_NAMED

#define WOLF_WARN_NAMED	(		name,
			...
	)

Value:

    {                                                                                                                 \
        char this_file[] = __FILE__;                                                                                  \
        wolf::internal::WolfLoggerManager::get().getLogger(name).warn(                                                \
            "[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__);                         \
    }

WOLF_WARN_NAMED_COND

#define WOLF_WARN_NAMED_COND	(		name,
			cond,
			...
	)		if (cond) WOLF_WARN_NAMED(name, __VA_ARGS__);